Overview Agile Cycle
Introduction The Agile life cycle refers to those processes involved in the development of software using the agile principles. Today, there are a variety of agile development software in the market, each offering a seemingly different methodology and approach. Accordingly, there is no single set of development phases that can be identified as the universal agile life cycle. Although the process might vary for different software, the underlying principle and objective are usually the same. For this reason, it is possible to develop a comprehensive set of developmental phases that can be identified as the general agile life cycle. According to Bhalerao et al. (222), the general agile life cycle consists of concept, inception, iteration, ADCT, and release. Stages The concept stage involves envisioning of the project and determining what the client is trying to build. This stage involves a detailed description of the client’s requirements and a description of the project scope and overall objectives. The participant stakeholders are also identified together with their subsequent roles in the project. This stage further involves conducting a feasibility study to assess the economic viability of the project, together with the estimated cost and the target market group. This study also provides information regarding the legislative requirements for the enterprise including legal and tax requirements (Leau et al., 163). The second stage, inception, involves providing those requirements required to initiate the design process after the concept stage has been completed. In Agile software, these requirements are referred to as stories, and they are documented in story cards. An example of an initial requirement is providing funding to kick-start the design process. This stage is also characterized by the selection of an appropriate and qualified design team, including but not limited to project managers, coders, and developers. The design team develops a prototypic software which is provided to a test team to further understand the requirements of the proposed system (Bhalerao et al., 224). During the iteration stage, the teams review the feedback on the prototypic software developed during the inception stage. The team builds on this information to develop a better product. This stage involves the prioritization of the identified requirements to get the maximum return on investment for the software (Mekni et al., 4). Accordingly, features that have higher financial returns will be addressed first before features technical features that consumers know little about or are not likely to appreciate. The acronym ACDT stands for Analysis, Design, Coding, and Testing. This phase involves enhancing the functionality of the designed system incrementally over time. This is done before the official release of the product because software usually requires several iterations before they are ready for consumption by the public. This, however, does not mean that after the software is released, it will not undergo further iterations. Instead, this stage attempts to elevate the software to an acceptable standard that can be consumed without incessant hitches or complications (Leau et al., 166). The final stage, release, consists of two sub-phases, namely, pre-release and production. Pre-release involves a limited release of the product select members of the public for extra testing before the production stage. This is done to identify any changes or improvements that can be made to the product before the official release. Production deals with the official release of the product for purchase and use by the public. After this stage, any further enhancements will be made available to users in the form of updates, (Mekni, et al., 4). Work Cited Leau, Yu Beng; Loo, Khong Wooi; Tham, Wai Yip and Tan, Soo Fun, "Software development life cycle AGILE vs traditional approaches." International Conference on Information and Network Technology. Vol. 37. No. 1. (2012): 162-166. Bhalerao, S., D. Puntambekar, and M. Ingle. "Generalizing Agile software development life cycle." International journal on computer science and engineering 1.3 (2009): 222-226. Mekni, Mehdi; Mounika, G., Sandeep, C. and Gayathri, B., "Software Architecture Methodology in Agile Environments." Journal of Information Technology Software Engineering 7.195 (2017): 2-8.